// 文章相关的路由
var express = require('express');
var router = express.Router();
// 导入数据库连接对象
var db = require("../db/db.js");
const dayjs = require("dayjs")

// 前端在用到这个文件中的接口时，就检查是否携带tokenquery
// router.use(function timeLog(req, res, next) {
//   console.log('Time: ', Date.now())
//   //模块路由中检测是否携带了 token
//   if (!req.auth) {
//     return res.send({
//       status: 403,
//       message: "缺少token"
//     });
//   }
//   next()
// })
var multipart = require('connect-multiparty');
var path = require("path")
var fs = require("fs");
const multipartMiddleware = multipart();


// 导入模型--后台
const { users, comment } = require("../model/comment.js");
const { Op, where } = require('sequelize');
// 评论的列表+分页
router.get("/comment_list", async (req, res) => {
  // 解构并验证分页参数
  const { page = 1, page_size = 10,arc_id=0 } = req.query; // 设置默认值
  const pageInt = parseInt(page, 10);
  const page_sizeInt = parseInt(page_size, 10);

  // 验证 page 和 page_size 是否为正整数
  if (isNaN(pageInt) || isNaN(page_sizeInt) || pageInt < 1 || page_sizeInt <= 0) {
    return res.status(400).json({ code: -1, msg: "无效的分页参数" });
  }

  const start = (pageInt - 1) * page_sizeInt;

  // 1. 创建一个空的 where 对象
  const whereCondition = {
    state: 0,
  };

  // 2. 判断 arc_id 是否有值，如果有，则添加到 where 对象中
  if (arc_id) {
    whereCondition.article_id = arc_id;
  }

  try {
    // 获取评论列表
    const comments = await comment.findAll({
      offset: start, // SQL中的偏移量
      limit: page_sizeInt, // 每页显示的记录数
      where: whereCondition //动态构建查询条件
    });

    // 返回成功响应
    res.json({
      code: 0,
      msg: "评论的列表获取成功",
      data: comments
    });
  } catch (error) {
    console.error(error);
    res.status(500).json({ code: -1, msg: "评论列表获取失败" });
  }
});

// 评论内容的搜索+分页
router.get("/comment_search", async (req, res) => {
  // 解构并验证分页参数
  const { page = 1, page_size = 10, search } = req.query; // 设置默认值并获取搜索参数
  const pageInt = parseInt(page, 10);
  const page_sizeInt = parseInt(page_size, 10);

  // 验证 page 和 page_size 是否为正整数
  if (isNaN(pageInt) || isNaN(page_sizeInt) || pageInt < 1 || page_sizeInt <= 0) {
    return res.status(400).json({ code: -1, msg: "无效的分页参数" });
  }

  const start = (pageInt - 1) * page_sizeInt;

  try {
    // 构建查询条件
    const whereClause = {
      limit: page_sizeInt,
      offset: start,
      where: {
        state: 0 // 默认查询条件
      }
    };

    // 如果提供了搜索参数，则添加到查询条件中
    if (search) {
      whereClause.where.content = {
        [Op.like]: `%${search}%` // 使用 Sequelize 的模糊查询
      };
    }

    // 获取评论列表
    const comments = await comment.findAll(whereClause);

    // 返回成功响应
    res.json({
      code: 0,
      msg: "评论搜索结果获取成功",
      data: comments
    });
  } catch (error) {
    console.error(error);
    res.status(500).json({ code: -1, msg: "评论搜索失败" });
  }
});

// 评论内容的修改-获取数据
router.get("/comment_getmsg/:id", async (req, res) => {
  const { id } = req.params;
  // 验证 id 是否为有效的数字
  const idInt = parseInt(id, 10);
  if (isNaN(idInt)) {
    return res.status(400).json({ code: -1, msg: "无效的评论ID" });
  }

  try {
    // 根据 ID 查询评论
    const comment_get = await comment.findOne({
      where: {
        id: idInt
      }
    });

    // 如果没有找到评论，返回404状态码
    if (!comment_get) {
      return res.status(404).json({ code: -1, msg: "评论不存在" });
    }

    // 返回成功响应
    res.json({
      code: 0,
      msg: "评论信息获取成功",
      data: comment_get
    });
  } catch (error) {
    console.error(error);
    res.status(500).json({ code: -1, msg: "获取评论信息失败" });
  }
});

// 评论内容的修改-保存数据
router.post("/comment_setmsg/:id", async (req, res) => {
  const { id } = req.params;
  const { content } = req.body;

  // 验证 id 是否为有效的数字
  const idInt = parseInt(id, 10);
  if (isNaN(idInt)) {
    return res.status(400).json({ code: -1, msg: "无效的评论ID" });
  }

  // 验证 content 是否存在且不为空
  if (!content || typeof content !== 'string') {
    return res.status(400).json({ code: -1, msg: "评论内容不能为空" });
  }

  try {
    // 根据 ID 更新评论内容
    const [affectedCount, affectedRows] = await comment.update(
      { content: content },
      {
        where: { id: idInt }
      }
    );

    // 如果没有行被更新，返回404状态码
    if (affectedCount === 0) {
      return res.status(404).json({ code: -1, msg: "评论不存在或更新失败" });
    }

    // 返回成功响应
    res.json({
      code: 0,
      msg: "评论内容的修改成功"
    });
  } catch (error) {
    console.error(error);
    res.status(500).json({ code: -1, msg: "评论内容修改失败" });
  }
});

// 评论内容的删除-软删除
router.get("/comment_del_state/:id", async (req, res) => {
  const { id } = req.params;

  // 验证 id 是否为有效的数字
  const idInt = parseInt(id, 10);
  if (isNaN(idInt)) {
    return res.status(400).json({ code: -1, msg: "无效的评论ID" });
  }

  try {
    // 根据 ID 更新评论状态
    const [affectedCount] = await comment.update(
      {
        state: 1 // 假设 state: 1 代表删除
      },
      {
        where: { id: idInt }
      }
    );

    // 如果没有行被更新，返回404状态码
    if (affectedCount === 0) {
      return res.status(404).json({ code: -1, msg: "评论不存在或更新失败" });
    }

    // 返回成功响应
    res.json({
      code: 0,
      msg: "此评论状态已改变，代表删除！"
    });
  } catch (error) {
    console.error(error);
    res.status(500).json({ code: -1, msg: "评论状态更新失败" });
  }
});

// 评论内容的删除-真*删除
router.get("/comment_del/:id", async (req, res) => {
  const { id } = req.params;

  // 验证 id 是否为有效的数字
  const idInt = parseInt(id, 10);
  if (isNaN(idInt)) {
    return res.status(400).json({ code: -1, msg: "无效的评论ID" });
  }

  try {
    // 根据 ID 删除评论
    const affectedCount = await comment.destroy({
      where: { id: idInt }
    });

    // 如果没有行被删除，返回404状态码
    if (affectedCount === 0) {
      return res.status(404).json({ code: -1, msg: "评论不存在或删除失败" });
    }

    // 返回成功响应
    res.json({
      code: 0,
      msg: "评论删除成功"
    });
  } catch (error) {
    console.error(error);
    res.status(500).json({ code: -1, msg: "评论删除失败" });
  }
});


// 上传图片--单个图片--路由
// 定义路由处理文件上传请求
router.post('/upload', multipartMiddleware, function (req, res) {
  // 获取上传的文件信息
  console.log("aaaa", req.files);
  /*
  编辑器中的输出内容：
  {
    file: {
      fieldName: 'file',
      originalFilename: 'html.jpg',
      path: 'C:\\Users\\lenovo\\AppData\\Local\\Temp\\969aA6lmX_W5zQbg1jGz6NAp.jpg',
      headers: {
        'content-disposition': 'form-data; name="file"; filename="html.jpg"',
        'content-type': 'image/jpeg'
      },
      size: 20536,
      name: 'html.jpg',
      type: 'image/jpeg'
    }
  }
  */
  /*
  ElementPlus中的文件上传组件的输出：
   {
     picture: {
       fieldName: 'picture',
       originalFilename: 'MBH-3.jpg',
       path: 'C:\\Users\\lenovo\\AppData\\Local\\Temp\\y6idMexCjJn4z0QlNdJ12wFe.jpg',
       headers: {
         'content-disposition': 'form-data; name="picture"; filename="MBH-3.jpg"',
         'content-type': 'image/jpeg'
       },
       size: 35082,
       name: 'MBH-3.jpg',
       type: 'image/jpeg'
     }
   }
  */
  let file = req.files.picture;
  var originalFilename = file.originalFilename;
  var file_path = file.path;

  // 读取文件内容并保存到新位置
  if (file_path) {
    let date = new Date();
    let new_name = date.getTime() + path.extname(originalFilename);
    let new_file_name = path.join('public', 'img', new_name);

    console.log("New file name:", new_file_name);

    // 创建读取流
    const readStream = fs.createReadStream(file_path);
    // 创建写入流
    const writeStream = fs.createWriteStream(new_file_name);

    readStream.on('error', (err) => {
      console.error('读取文件时出错:', err);
      res.json({ status: -1, msg: err.message });
    });

    writeStream.on('error', (err) => {
      console.error('写入文件时出错:', err);
      res.json({ status: -1, msg: err.message });
    });

    readStream.on('close', () => {
      console.log('文件读取完成');
      res.json({
        msg: "文件上传完成", code: 0, data: {
          fileName: `/img/${new_name}`,
          ext: path.extname(new_file_name)
        }
      });
    });

    readStream.pipe(writeStream);
  } else {
    res.status(500).send('Error occurred while saving the file.');
  }
});
// 文件删除接口
router.post('/deleteUpload', function (req, res) {
  // 假设客户端发送了要删除的文件名
  const fileName = req.body.fileName; // 例如: "/img/1623456789012.jpg"
  console.log(req.body)
  if (!fileName) {
    return res.status(400).send('缺少文件名参数');
  }

  // 从文件名中提取文件路径
  const filePath = path.join('public', 'img', path.basename(fileName));

  // 检查文件是否存在
  fs.access(filePath, fs.constants.F_OK, (err) => {
    if (err) {
      return res.status(404).send('文件不存在');
    }

    // 删除文件
    fs.unlink(filePath, (err) => {
      if (err) {
        return res.status(500).send('删除文件时出错');
      }
      res.json({ msg: '文件删除成功', code: 0 });
    });
  });
});

// 增加文章标题重复检测接口、功能
router.get("/check", function (req, res) {
  const { title } = req.query;

  // 使用参数化查询来防止SQL注入
  let sql = "SELECT * FROM article WHERE title = ?";

  db(sql, [title], (error, results) => {
    if (error) {
      console.error(error);
      return res.status(500).json({ msg: "服务器错误，请稍后再试。", code: 500 });
    } else {
      if (results.length > 0 && results[0].title === title) {
        // 如果文章存在，发送相应的消息
        res.json({ msg: "此文章标题已经存在，请换个标题吧！", code: 1 });
      } else {
        // 如果文章不存在，发送成功消息
        res.json({ msg: "ok", code: 0, results });
      }
    }
  });
});

/* 1.文章分类数据 */
// /article/cate_list
router.get('/cate_list', function (req, res, next) {
  // 获取查询参数
  const { page = 1, page_size = 10, cate_name, is_show } = req.query;

  // 计算起始记录
  const start = (page - 1) * page_size;

  // 构建基础 SQL 查询
  let sql = "SELECT id, cate_name, order_num, is_show FROM cate";
  const params = [];

  // 构建 WHERE 子句
  let whereClause = '';
  let whereConditions = [];

  if (cate_name) {
    whereConditions.push("cate_name LIKE ?");
    params.push(`%${cate_name}%`);
  }
  if (is_show !== undefined && is_show !== '') {
    whereConditions.push("is_show = ?");
    params.push(is_show);
  }

  if (whereConditions.length > 0) {
    whereClause = ` WHERE ${whereConditions.join(' AND ')}`;
  }

  // 添加 WHERE 子句
  if (whereClause) {
    sql += whereClause;
  }

  // 添加 ORDER BY 子句
  sql += " ORDER BY order_num ASC,id DESC";

  // 添加 LIMIT 子句
  sql += ` LIMIT ?, ?`;
  params.push(start);
  params.push(Number(page_size));

  // 执行查询获取分页数据
  db(sql, params, function (err, result) {
    if (err) {
      console.error(err);
      res.json({ msg: "查询出错啦", code: -1 });
    } else {
      // 构建查询总数的 SQL
      let countSql = `SELECT COUNT(*) AS total FROM cate ${whereClause}`;

      // 执行查询获取总数
      db(countSql, params, function (countErr, countResult) {
        if (countErr) {
          console.error(countErr);
          res.json({ msg: "查询总数出错", code: -2 });
        } else {

          const total = countResult[0].total;
          res.json({ msg: "ok", code: 0, result, total });
        }
      });
    }
  });
});


// 1.1分类库（cate）的删除
router.get('/cate_delete/:id', (req, res) => {
  console.log(req.params.id)
  db('DELETE FROM cate WHERE id = ?', [parseInt(req.params.id)],
    function (error, result) {
      if (error) {
        res.json({ code: 1, msg: "删除失败", data: { err } })
      } else {
        res.json({ code: 0, msg: "删除成功" })
      }
    }
  )
})

// 1.2分类库（cate）的增加
router.post('/cate_add', (req, res) => {
  // 先获取用户的请求数据，存到变量“body”中
  var body = req.body
  // 用结构复制把用户请求数据里面的的“uname,part,mobile, pwd”分别拿出来，方便接下来向数据库中添加数据时使用
  let { cate_name, order_num, is_show } = body

  db('SELECT id,cate_name FROM cate where cate_name = ?', [cate_name], function (error, results) {
    if (results.length > 0) {
      res.send({ data: [], code: -1, msg: "此分类已经存在" }) //标准返回信息
    } else {
      db(
        'INSERT INTO cate (cate_name,order_num,is_show) VALUES (?,?,?)',
        [cate_name, order_num, is_show],
        function (err, results) {
          //  响应数据
          if (err) {
            res.json({ code: 1, msg: "操作失败", data: { err } })
          } else {
            res.json({ code: 0, msg: "添加完成", data: { cate_name: cate_name } })
          }
          console.log(err + 'ok了!')
        });
    }
  })
  // res.json({ msg: "人员添加", code: 1, data: [] })
})

// 1.3分类库（cate）的修改--获取数据
router.get('/cate_edit/:id', (req, res) => {
  // 打印请求参数
  console.log(req.query, req.params);
  // 检查id参数是否存在
  if (!req.params.id) {
    return res.status(400).send({ code: -1, msg: '缺少参数', data: [] });
  }
  // 尝试将id转换为整数，如果失败则返回错误
  const id = parseInt(req.params.id);
  if (isNaN(id)) {
    return res.status(400).send({ code: 1, msg: '无效的参数', data: [] });
  }
  // 准备SQL查询语句
  const selectSQL = 'SELECT id,cate_name,order_num,is_show FROM cate WHERE id=?';

  // 执行数据库查询
  db(selectSQL, [id], (error, results) => {
    if (error) {
      // 处理数据库查询错误
      return res.status(500).send({ code: 2, msg: '数据库查询错误', data: [] });
    }

    // 响应数据
    res.send({
      code: 0,
      msg: '查询数据',
      data: { ...results[0] }
    });
  });
});

// 1.4分类库（cate）的修改--保存数据
router.post('/cate_save_edit/:id', (req, res) => {
  // 从动态路由参数中获取id
  const id = req.params.id;
  // 从请求体中获取分类名称
  const { cate_name, order_num, is_show } = req.body;

  // 验证参数
  if (!id || !cate_name) {
    return res.status(400).json({ msg: '缺少必要的参数', code: 1, data: {} });
  }
  // 尝试将id转换为整数，如果失败则返回错误
  const numericId = parseInt(id);
  if (isNaN(numericId)) {
    return res.status(400).json({ msg: '无效的参数', code: 1, data: {} });
  }
  // 准备SQL更新语句
  const updateSQL = 'UPDATE cate SET cate_name=?,order_num=?,is_show=? WHERE id=?';

  // 执行数据库更新
  db(updateSQL, [cate_name, order_num, is_show, numericId], (error, results) => {
    if (error) {
      console.error(error);
      return res.status(500).json({ msg: '数据库更新失败', code: 2, data: {} });
    }
    // 根据更新结果响应信息
    if (results.affectedRows > 0) {
      res.json({ msg: '修改完毕', code: 0, data: { cate_name, order_num, is_show, id: numericId } });
    } else {
      res.status(404).json({ msg: '未找到对应的分类', code: 3, data: {} });
    }
  });
});

// 1.5分类（cate）的搜索--分页
router.get('/cate_search_product', (req, res) => {
  // 获取url中的参数 ?keyword=xxx, 参数放在req.query中 { keyword: 'xxx' }
  let { keyword, page, page_size } = req.query;

  // 验证搜索关键词是否存在
  if (!keyword) {
    return res.status(400).json({ code: 1, msg: '缺少搜索关键词', data: {} });
  }
  // 查询limit
  let start = (page - 1) * page_size;
  let limit = ` limit ${start}, ${page_size}`;

  // 构造搜索SQL语句，使用参数化查询防止SQL注入
  let searchSQL = `
  SELECT id, cate_name 
  FROM cate 
  WHERE cate_name LIKE ? 
  ${limit}`;
  db(searchSQL, [`%${keyword}%`], (error, results) => { // 使用%作为通配符进行模糊匹配
    if (error) {
      console.log(error);
      return res.status(500).json({ code: 1, msg: '数据库查询错误', data: {} });
    }
    let arr = results.map(item => ({
      id: item.id,
      cate_name: item.cate_name,
    }));
    // 查询总条数
    let countSQL = "SELECT COUNT(*) as total FROM cate WHERE cate_name LIKE ?";
    db(countSQL, [`%${keyword}%`], (err, countResults) => {
      if (err) {
        console.log(err);
        return res.status(500).json({ code: 1, msg: '数据库查询错误', data: {} });
      }
      let totalNum = countResults[0].total;
      res.json({
        code: 0,
        msg: "搜索结果",
        data: { arr, totalNum }  // 在响应数据中加入总数
      });
    });
  });
});

// 2.文章分类列表、搜索、分页
router.get("/list", function (req, res) {
  // 取参数
  const { page = 1, page_size = 8, cate_id } = req.query;

  console.log(req.query)

  let where = ' WHERE 1 = 1 ';

  var data = []
  // 查询limit
  let start = (page - 1) * page_size;
  //  let limit = `${start},${page_size}`;

  if (cate_id) {
    where += `AND a.cate_id = ${cate_id}`;
  }

  //查询数据
  var sql = `SELECT a.id, a.cate_id, a.title, a.sub_title, a.recommend,a.content, a.view, a.like, b.username, a.pic, a.ctime, c.cate_name
FROM article AS a
LEFT JOIN users AS b ON a.user_id = b.id
LEFT JOIN cate AS c ON a.cate_id = c.id
${where} 
ORDER BY a.id DESC
LIMIT ${start}, ${page_size}`;
  var data = [cate_id, start, Number(page_size)];

  db(sql, data, function (err, result) {
    if (err) {
      console.log(err, err.sql)
      res.json({ "msg": "数据库处理异常", "code": -2 })
      return;
    }
    // 
    let totalSQL = `SELECT COUNT(id) as total from article AS a ${where} `
    db(totalSQL, function (err, ret) {
      console.log(err)
      const total = ret[0].total;
      const total_page = Math.ceil(total / page_size)
      console.log(result)
      res.json({ msg: 'ok', data: { list: result, total_page, total_records: total }, "code": 0 })
    });
    /* 
    {
      msg:"ok",
      result:[
        {
          "id": 7,
          "title": "用OO方法解一道算术题",
          "sub_title": "本篇主要为说明使用面向对象的分析和设计方法可以帮助更快地认识事物，更快地排除编程设计过程一个个拦路虎。",
          "view": 129,
          "like": 10,
          "username": "future"
        }
        ...
      ],
      code:0
    }
    */
  })

})

// 2.1 删除文章
router.get("/article_delete", function (req, res) {
  var query = req.query; // {"id":"1"}

  // 检测参数是否存在
  if (!query.id) {
    res.json({ "msg": "缺少参数", "code": -1 });
    return;
  }

  // 验证参数是否为有效的ID
  if (isNaN(query.id) || query.id <= 0) {
    res.json({ "msg": "参数不合法", "code": -3 });
    return;
  }

  // 构建删除SQL语句
  var sql = "DELETE FROM article WHERE id = ?";
  var data = [query.id];

  db(sql, data, function (err, result) {
    if (err) {
      res.json({ "msg": "数据库处理异常", "code": -2 });
      return;
    }
    if (result.affectedRows === 0) {
      res.json({ "msg": "未找到对应的记录", "code": -4 });
      return;
    }
    res.json({ msg: '删除成功', "code": 0 });
  });
});

// 2.2 添加文章
router.post("/article_add", function (req, res) {
  // 获取请求体中的数据
  var body = req.body;
  console.log('add article:',body)
  const { uid, username } = req.auth;//从token中取到用户数据

  // 检测必要参数是否存在
  if (!body.title || !body.sub_title || !body.cate_id || !body.content) {
    res.json({ "msg": "缺少必要参数", "code": -1 });
    return;
  }
  // 构建插入SQL语句
  var sql = "INSERT INTO article (title, sub_title, cate_id, `view`, `like`, username,user_id, content, ctime) VALUES (?,?, ?, ?, ?, ?, ?, ?, ?)";
  
  // 1730862679 499 生成毫秒时间，且日期不对
  // let date = new Date();
  // let time = date.getTime();
  // 使用dayjs 解决
  let time = dayjs().unix();       // unix返回的是秒(s)，是标准的时间戳
  // let time = dayjs().valueOf(); // valueOf返回的是毫秒(ms)
  let time_formate = dayjs.unix(time).format('YYYY-MM-DD HH:mm:ss') //按时间戳转为标准的js对象
  console.log(time)

  var data = [
    body.title,
    body.sub_title,
    body.cate_id,
    body.view || 0, // 浏览量默认为0
    body.like || 0, // 点赞数默认为0
    username,
    uid,
    body.content,
    time// 使用当前时间作为创建时间
  ];

  db(sql, data, function (err, result) {
    if (err) {
      console.log(err)
      res.json({ "msg": "数据库处理异常", "code": -2 });
      return;
    }
    res.json({ msg: '添加成功:', "code": 0, "insertId": result.insertId });
  });
});

// 2.3 修改文章-获取数据
router.get('/article_edit/:id', (req, res) => {
  // 打印请求参数
  console.log(req.query, req.params);

  // 检查id参数是否存在
  if (!req.params.id) {
    return res.status(400).send({ code: -1, msg: '缺少参数', data: [] });
  }
  // 尝试将id转换为整数，如果失败则返回错误
  const id = parseInt(req.params.id);
  if (isNaN(id)) {
    return res.status(400).send({ code: 1, msg: '无效的参数', data: [] });
  }
  // 准备SQL查询语句
  const selectSQL = 'SELECT id,title, sub_title, cate_id, content,`view`, `like`,user_id, username, pic,recommend, ctime FROM article WHERE id=?';
  // 执行数据库查询
  db(selectSQL, [id], (error, results) => {
    if (error) {
      console.log(error)
      // 处理数据库查询错误
      return res.status(500).send({ code: 2, msg: '数据库查询错误', data: [] });
    }
    // 检查查询结果
    if (results.length === 0) {
      return res.status(404).send({ code: 3, msg: '未找到对应的分类', data: [] });
    }
    // 响应数据
    res.send({
      code: 0,
      msg: '查询数据',
      data: results[0] // 直接将查询结果的第一个元素（也是唯一一个元素）响应到前端
    });
  });
});

// 2.4 修改文章-保存数据
router.post('/article_save_edit/:id', (req, res) => {
  // 从动态路由参数中获取id
  const id = req.params.id;
  const { uid, username } = req.auth;//多token中取到用户数据

  // 从请求体中获取文章信息
  const {
    title, sub_title, content, recommend = 0, cate_id, view, like, pic, ctime
  } = req.body;

  // 验证参数
  if (!id || !title || !sub_title || !content || !cate_id || !view || !like) {
    return res.status(400).json({ msg: '缺少必要的参数', code: 1, data: {} });
  }
  // 尝试将id转换为整数，如果失败则返回错误
  const numericId = parseInt(id);
  if (isNaN(numericId)) {
    return res.status(400).json({ msg: '无效的参数', code: 1, data: {} });
  }
  // 准备SQL更新语句
  const updateSQL = `
  UPDATE article 
  SET title=?, sub_title=?, cate_id=?,content=?,recommend=?, \`view\`=?, \`like\`=?, username=?, user_id=?, pic= ?, ctime=? 
  WHERE id=?`;

  // 表单数据
  const formData = [title, sub_title, cate_id, content, recommend, view, like, username, uid, pic, ctime, numericId];

  // 执行数据库更新
  db(updateSQL, formData, (error, results) => {
    if (error) {
      console.error(error);
      return res.status(500).json({ msg: '数据库更新失败', code: 2, data: {} });
    }
    // 根据更新结果响应信息
    if (results.affectedRows > 0) {
      // 如果需要返回更新后的数据，可以在这里再次查询数据库
      // 构建查询SQL语句以获取更新后的数据
      const selectSQL = 'SELECT title, sub_title, cate_id, `view`, `like`, username,user_id,recommend, pic, ctime FROM article WHERE id=?';

      db(selectSQL, [numericId], (selectError, selectResults) => {
        if (selectError) {
          console.error(selectError);
          return res.status(500).json({ msg: '获取更新数据失败', code: 4, data: {} });
        }
        // 响应更新后的数据
        res.json({
          msg: '修改完毕',
          code: 0,
          data: selectResults[0] // 假设查询结果只有一条记录
        });
      });
    } else {
      res.status(404).json({ msg: '未找到对应的文章', code: 3, data: {} });
    }
  });
});

// 2.5 文章搜索--分页数据接口-废弃
router.get('/article_search_product', (req, res) => {
  // 获取url中的参数，参数放在req.query中
  let { title, sub_title, cate_id, view, like, username, pic, ctime, page, page_size } = req.query;
  // 验证分页参数
  if (page === undefined || page_size === undefined) {
    return res.status(400).json({ code: 1, msg: '缺少分页参数', data: {} });
  }
  // 尝试将分页参数转换为整数，如果失败则返回错误
  const pageInt = parseInt(page);
  const page_sizeInt = parseInt(page_size);
  if (isNaN(pageInt) || isNaN(page_sizeInt)) {
    return res.status(400).json({ code: 1, msg: '分页参数无效', data: {} });
  }
  // 计算limit的起始位置
  const start = (pageInt - 1) * page_sizeInt;
  const limit = ` LIMIT ${start}, ${page_sizeInt}`;
  // 构造搜索条件
  let conditions = [];
  if (title) conditions.push(`title LIKE ?`);
  if (sub_title) conditions.push(`sub_title LIKE ?`);
  if (cate_id) conditions.push(`cate_id = ?`);
  if (view) conditions.push(`view = ?`);
  if (like) conditions.push(`like = ?`);
  if (username) conditions.push(`username LIKE ?`);
  if (pic) conditions.push(`pic LIKE ?`);
  if (ctime) conditions.push(`ctime = ?`);
  // 如果没有任何搜索条件，则返回错误
  if (conditions.length === 0) {
    return res.status(400).json({ code: 1, msg: '缺少搜索条件', data: {} });
  }
  // 构造搜索SQL语句，使用参数化查询防止SQL注入
  let searchSQL = `SELECT * FROM article WHERE ${conditions.join(' AND ')} ${limit}`;
  let params = [];
  if (title) params.push(`%${title}%`);
  if (sub_title) params.push(`%${sub_title}%`);
  if (cate_id) params.push(cate_id);
  if (view) params.push(view);
  if (like) params.push(like);
  if (username) params.push(`%${username}%`);
  if (pic) params.push(`%${pic}%`);
  if (ctime) params.push(ctime);

  // 执行数据库查询
  db(searchSQL, params, (error, results) => {
    if (error) {
      console.log(error);
      return res.status(500).json({ code: 1, msg: '数据库查询错误', data: {} });
    }
    // 查询总条数
    let countSQL = `SELECT COUNT(*) as total FROM article WHERE ${conditions.join(' AND ')}`;
    db(countSQL, params, (err, countResults) => {
      if (err) {
        console.log(err);
        return res.status(500).json({ code: 1, msg: '数据库查询错误', data: {} });
      }
      let totalNum = countResults[0].total;
      res.json({
        code: 0,
        msg: "搜索结果",
        data: { results, totalNum }  // 在响应数据中加入总数
      });
    });
  });
});

// 3. 文章详情
// /article/detail?id=1
router.get("/detail", (req, res) => {
  //1。获取id
  var params = req.query;
  if (!params.id) {
    res.json({ msg: "缺少参数", code: -1 })
  }
  //2.查询id对应的博客内容
  var sql = "select id,title,sub_title,`view`,`like`,username,content,pic,recommend,ctime from article where id=?";
  var data = [params.id];
  db(sql, data, (err, result) => {
    if (err) {
      console.log(err)
      return res.json({ msg: "数据库异常", code: -1 })
    }
    res.json({ msg: "ok", code: 0, result: result[0] })
  })
  // 
})

// 4. 文章搜索-废弃
// /article/search
router.post("/search", function (req, res) {
  console.log(req.body)

  if (!req.body.keywords) {
    res.json({ msg: "缺少参数", code: -2 })
  }

  let keywords = req.body.keywords;
  let sql = "SELECT id,title,sub_title,`view`,`like`,`username`,pic,ctime from article where title like ? or content like ? order by id desc limit 6";

  let words = `%${keywords}%`;
  let data = [words, words];

  db(sql, data, function (err, result) {
    if (err) {
      console.log(err)
      res.json({ msg: "查询出错啦" + err.message, code: -1 })
    }
    res.json({ msg: "ok", code: 0, result })
  })
})

// 5.更新文章访问次数
// /article/update_view
router.post("/update_view", function (req, res) {
  const aid = req.body.id;
  if (!aid) {
    res.json({ msg: "缺少参数", code: -2 })
  }

  let sql = "UPDATE article set `view`=view+1 WHERE id=?";
  let data = [aid];

  db(sql, data, function (err, result) {
    if (err) {
      res.json({ msg: "查询出错啦" + err.message, code: -1 })
    }
    res.json({ msg: "更新成功", code: 0, data: [] })
  })
})

module.exports = router;